{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GDDVue_1cq6d"
   },
   "source": [
    "# NVIDIA AI Foundation Endpoints \n",
    "\n",
    "> [NVIDIA AI Foundation Endpoints](https://www.nvidia.com/en-us/ai-data-science/foundation-models/) give users easy access to NVIDIA hosted API endpoints for NVIDIA AI Foundation Models like Mixtral 8x7B, Llama 2, Stable Diffusion, etc. These models, hosted on the [NVIDIA NGC catalog](https://catalog.ngc.nvidia.com/ai-foundation-models), are optimized, tested, and hosted on the NVIDIA AI platform, making them fast and easy to evaluate, further customize, and seamlessly run at peak performance on any accelerated stack.\n",
    "> \n",
    "> With [NVIDIA AI Foundation Endpoints](https://www.nvidia.com/en-us/ai-data-science/foundation-models/), you can get quick results from a fully accelerated stack running on [NVIDIA DGX Cloud](https://www.nvidia.com/en-us/data-center/dgx-cloud/). Once customized, these models can be deployed anywhere with enterprise-grade security, stability, and support using [NVIDIA AI Enterprise](https://www.nvidia.com/en-us/data-center/products/ai-enterprise/).\n",
    "> \n",
    "> These models can be easily accessed via the [`langchain-nvidia-ai-endpoints`](https://pypi.org/project/langchain-nvidia-ai-endpoints/) package, as shown below.\n",
    "\n",
    "This example goes over how to use LangChain to interact with the supported [NVIDIA Retrieval QA Embedding Model](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/ai-foundation/models/nvolve-40k) for [retrieval-augmented generation](https://developer.nvidia.com/blog/build-enterprise-retrieval-augmented-generation-apps-with-nvidia-retrieval-qa-embedding-model/) via the `NVIDIAEmbeddings` class.\n",
    "\n",
    "For more information on accessing the chat models through this api, check out the [ChatNVIDIA](../chat/nvidia_ai_endpoints) documentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install --upgrade --quiet  langchain-nvidia-ai-endpoints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qKcxQMFTcwWi"
   },
   "source": [
    "## Setup\n",
    "\n",
    "**To get started:**\n",
    "\n",
    "1. Create a free account with the [NVIDIA NGC](https://catalog.ngc.nvidia.com/) service, which hosts AI solution catalogs, containers, models, etc.\n",
    "\n",
    "2. Navigate to `Catalog > AI Foundation Models > (Model with API endpoint)`.\n",
    "\n",
    "3. Select the `API` option and click `Generate Key`.\n",
    "\n",
    "4. Save the generated key as `NVIDIA_API_KEY`. From there, you should have access to the endpoints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hoF41-tNczS3",
    "outputId": "7f2833dc-191c-4d73-b823-7b2745a93a2f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid NVIDIA_API_KEY already in environment. Delete to reset\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "\n",
    "## API Key can be found by going to NVIDIA NGC -> AI Foundation Models -> (some model) -> Get API Code or similar.\n",
    "## 10K free queries to any endpoint (which is a lot actually).\n",
    "\n",
    "# del os.environ['NVIDIA_API_KEY']  ## delete key and reset\n",
    "if os.environ.get(\"NVIDIA_API_KEY\", \"\").startswith(\"nvapi-\"):\n",
    "    print(\"Valid NVIDIA_API_KEY already in environment. Delete to reset\")\n",
    "else:\n",
    "    nvapi_key = getpass.getpass(\"NVAPI Key (starts with nvapi-): \")\n",
    "    assert nvapi_key.startswith(\"nvapi-\"), f\"{nvapi_key[:5]}... is not a valid key\"\n",
    "    os.environ[\"NVIDIA_API_KEY\"] = nvapi_key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "l185et2kc8pS"
   },
   "source": [
    "We should be able to see an embedding model among that list which can be used in conjunction with an LLM for effective RAG solutions. We can interface with this model pretty easily with the help of the `NVIDIAEmbeddings` model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialization\n",
    "\n",
    "The main requirement when initializing an embedding model is to provide the model name. An example is `nvolveqa_40k` below.\n",
    "\n",
    "For `nvovleqa_40k`, you can also specify the `model_type` as `passage` or `query`. When doing retrieval, you will get best results if you embed the source documents with the `passage` type and the user queries with the `query` type.\n",
    "\n",
    "If not provided, the `embed_query` method will default to the `query` type, and the `embed_documents` mehod will default to the `passage` type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "hbXmJssPdIPX"
   },
   "outputs": [],
   "source": [
    "from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings\n",
    "\n",
    "embedder = NVIDIAEmbeddings(model=\"nvolveqa_40k\")\n",
    "\n",
    "# Alternatively, if you want to specify whether it will use the query or passage type\n",
    "# embedder = NVIDIAEmbeddings(model=\"nvolveqa_40k\", model_type=\"passage\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SvQijbCwdLXB"
   },
   "source": [
    "This model is a fine-tuned E5-large model which supports the expected `Embeddings` methods including:\n",
    "\n",
    "- `embed_query`: Generate query embedding for a query sample.\n",
    "\n",
    "- `embed_documents`: Generate passage embeddings for a list of documents which you would like to search over.\n",
    "\n",
    "- `aembed_quey`/`embed_documents`: Asynchronous versions of the above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pcDu3v4CbmWk"
   },
   "source": [
    "### **Similarity/Speed Test**\n",
    "\n",
    "The following is a quick test of the methods in terms of usage, format, and speed for the use case of embedding the following data points:\n",
    "\n",
    "**Queries:**\n",
    "\n",
    "- What's the weather like in Komchatka?\n",
    "\n",
    "- What kinds of food is Italy known for?\n",
    "\n",
    "- What's my name? I bet you don't remember...\n",
    "\n",
    "- What's the point of life anyways?\n",
    "\n",
    "- The point of life is to have fun :D\n",
    "\n",
    "**Documents:**\n",
    "\n",
    "- Komchatka's weather is cold, with long, severe winters.\n",
    "\n",
    "- Italy is famous for pasta, pizza, gelato, and espresso.\n",
    "\n",
    "- I can't recall personal names, only provide information.\n",
    "\n",
    "- Life's purpose varies, often seen as personal fulfillment.\n",
    "\n",
    "- Enjoying life's moments is indeed a wonderful approach."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xrmtRzgXdhMF"
   },
   "source": [
    "### Embedding Runtimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bUQM6OoObM_C",
    "outputId": "afbb1ea0-4f14-46b0-da42-25c5ae8eab2e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Single Query Embedding: \n",
      "\u001b[1mExecuted in 2.19 seconds.\u001b[0m\n",
      "Shape: (1024,)\n",
      "\n",
      "Sequential Embedding: \n",
      "\u001b[1mExecuted in 3.16 seconds.\u001b[0m\n",
      "Shape: (5, 1024)\n",
      "\n",
      "Batch Query Embedding: \n",
      "\u001b[1mExecuted in 1.23 seconds.\u001b[0m\n",
      "Shape: (5, 1024)\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "print(\"Single Query Embedding: \")\n",
    "s = time.perf_counter()\n",
    "q_embedding = embedder.embed_query(\"What's the weather like in Komchatka?\")\n",
    "elapsed = time.perf_counter() - s\n",
    "print(\"\\033[1m\" + f\"Executed in {elapsed:0.2f} seconds.\" + \"\\033[0m\")\n",
    "print(\"Shape:\", (len(q_embedding),))\n",
    "\n",
    "print(\"\\nSequential Embedding: \")\n",
    "s = time.perf_counter()\n",
    "q_embeddings = [\n",
    "    embedder.embed_query(\"What's the weather like in Komchatka?\"),\n",
    "    embedder.embed_query(\"What kinds of food is Italy known for?\"),\n",
    "    embedder.embed_query(\"What's my name? I bet you don't remember...\"),\n",
    "    embedder.embed_query(\"What's the point of life anyways?\"),\n",
    "    embedder.embed_query(\"The point of life is to have fun :D\"),\n",
    "]\n",
    "elapsed = time.perf_counter() - s\n",
    "print(\"\\033[1m\" + f\"Executed in {elapsed:0.2f} seconds.\" + \"\\033[0m\")\n",
    "print(\"Shape:\", (len(q_embeddings), len(q_embeddings[0])))\n",
    "\n",
    "print(\"\\nBatch Query Embedding: \")\n",
    "s = time.perf_counter()\n",
    "# To use the \"query\" mode, we have to add it as an instance arg\n",
    "q_embeddings = NVIDIAEmbeddings(\n",
    "    model=\"nvolveqa_40k\", model_type=\"query\"\n",
    ").embed_documents(\n",
    "    [\n",
    "        \"What's the weather like in Komchatka?\",\n",
    "        \"What kinds of food is Italy known for?\",\n",
    "        \"What's my name? I bet you don't remember...\",\n",
    "        \"What's the point of life anyways?\",\n",
    "        \"The point of life is to have fun :D\",\n",
    "    ]\n",
    ")\n",
    "elapsed = time.perf_counter() - s\n",
    "print(\"\\033[1m\" + f\"Executed in {elapsed:0.2f} seconds.\" + \"\\033[0m\")\n",
    "print(\"Shape:\", (len(q_embeddings), len(q_embeddings[0])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SfX00xRdbKDw"
   },
   "source": [
    "### Document Embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "o1vKyTx-O_vZ",
    "outputId": "a8d864a8-01e8-4431-ee8a-b466d8348bef"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Single Document Embedding: \n",
      "\u001b[1mExecuted in 0.52 seconds.\u001b[0m\n",
      "Shape: (1024,)\n",
      "\n",
      "Batch Document Embedding: \n",
      "\u001b[1mExecuted in 0.89 seconds.\u001b[0m\n",
      "Shape: (5, 1024)\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "print(\"Single Document Embedding: \")\n",
    "s = time.perf_counter()\n",
    "d_embeddings = embedder.embed_documents(\n",
    "    [\n",
    "        \"Komchatka's weather is cold, with long, severe winters.\",\n",
    "    ]\n",
    ")\n",
    "elapsed = time.perf_counter() - s\n",
    "print(\"\\033[1m\" + f\"Executed in {elapsed:0.2f} seconds.\" + \"\\033[0m\")\n",
    "print(\"Shape:\", (len(q_embedding),))\n",
    "\n",
    "print(\"\\nBatch Document Embedding: \")\n",
    "s = time.perf_counter()\n",
    "d_embeddings = embedder.embed_documents(\n",
    "    [\n",
    "        \"Komchatka's weather is cold, with long, severe winters.\",\n",
    "        \"Italy is famous for pasta, pizza, gelato, and espresso.\",\n",
    "        \"I can't recall personal names, only provide information.\",\n",
    "        \"Life's purpose varies, often seen as personal fulfillment.\",\n",
    "        \"Enjoying life's moments is indeed a wonderful approach.\",\n",
    "    ]\n",
    ")\n",
    "elapsed = time.perf_counter() - s\n",
    "print(\"\\033[1m\" + f\"Executed in {elapsed:0.2f} seconds.\" + \"\\033[0m\")\n",
    "print(\"Shape:\", (len(q_embeddings), len(q_embeddings[0])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "E6AilXxjdm1I"
   },
   "source": [
    "Now that we've generated our embeddings, we can do a simple similarity check on the results to see which documents would have triggered as reasonable answers in a retrieval task:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install --upgrade --quiet  matplotlib scikit-learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 564
    },
    "id": "7szaiBBYCHQ-",
    "outputId": "86b6d2c4-6bee-4324-f7b1-3fcf2b940763"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "\n",
    "# Assuming embeddings1 and embeddings2 are your two sets of vectors\n",
    "# Compute the similarity matrix between embeddings1 and embeddings2\n",
    "cross_similarity_matrix = cosine_similarity(\n",
    "    np.array(q_embeddings),\n",
    "    np.array(d_embeddings),\n",
    ")\n",
    "\n",
    "# Plotting the cross-similarity matrix\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.imshow(cross_similarity_matrix, cmap=\"Greens\", interpolation=\"nearest\")\n",
    "plt.colorbar()\n",
    "plt.title(\"Cross-Similarity Matrix\")\n",
    "plt.xlabel(\"Query Embeddings\")\n",
    "plt.ylabel(\"Document Embeddings\")\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K5sLkHWZcRF2"
   },
   "source": [
    "As a reminder, the queries and documents sent to our system were:\n",
    "\n",
    "**Queries:**\n",
    "\n",
    "- What's the weather like in Komchatka?\n",
    "\n",
    "- What kinds of food is Italy known for?\n",
    "\n",
    "- What's my name? I bet you don't remember...\n",
    "\n",
    "- What's the point of life anyways?\n",
    "\n",
    "- The point of life is to have fun :D\n",
    "\n",
    "**Documents:**\n",
    "\n",
    "- Komchatka's weather is cold, with long, severe winters.\n",
    "\n",
    "- Italy is famous for pasta, pizza, gelato, and espresso.\n",
    "\n",
    "- I can't recall personal names, only provide information.\n",
    "\n",
    "- Life's purpose varies, often seen as personal fulfillment.\n",
    "\n",
    "- Enjoying life's moments is indeed a wonderful approach."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RNIeY4N96v3B"
   },
   "source": [
    "## RAG Retrieval:\n",
    "\n",
    "The following is a repurposing of the initial example of the [LangChain Expression Language Retrieval Cookbook entry](\n",
    "https://python.langchain.com/docs/expression_language/cookbook/retrieval), but executed with the AI Foundation Models' [Mixtral 8x7B Instruct](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/ai-foundation/models/mixtral-8x7b) and [NVIDIA Retrieval QA Embedding](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/ai-foundation/models/nvolve-40k) models available in their playground environments. The subsequent examples in the cookbook also run as expected, and we encourage you to explore with these options.\n",
    "\n",
    "**TIP:** We would recommend using Mixtral for internal reasoning (i.e. instruction following for data extraction, tool selection, etc.) and Llama-Chat for a single final \"wrap-up by making a simple response that works for this user based on the history and context\" response."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "zn_zeRGP64DJ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install --upgrade --quiet  langchain faiss-cpu tiktoken\n",
    "\n",
    "from operator import itemgetter\n",
    "\n",
    "from langchain_community.vectorstores import FAISS\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "from langchain_core.prompts import ChatPromptTemplate\n",
    "from langchain_core.runnables import RunnablePassthrough\n",
    "from langchain_nvidia_ai_endpoints import ChatNVIDIA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "id": "zIXyr9Vd7CED",
    "outputId": "a8d36812-c3e0-4fd4-804a-4b5ba43948e5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Based on the document provided, Harrison worked at Kensho.'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vectorstore = FAISS.from_texts(\n",
    "    [\"harrison worked at kensho\"],\n",
    "    embedding=NVIDIAEmbeddings(model=\"nvolveqa_40k\"),\n",
    ")\n",
    "retriever = vectorstore.as_retriever()\n",
    "\n",
    "prompt = ChatPromptTemplate.from_messages(\n",
    "    [\n",
    "        (\n",
    "            \"system\",\n",
    "            \"Answer solely based on the following context:\\n<Documents>\\n{context}\\n</Documents>\",\n",
    "        ),\n",
    "        (\"user\", \"{question}\"),\n",
    "    ]\n",
    ")\n",
    "\n",
    "model = ChatNVIDIA(model=\"mixtral_8x7b\")\n",
    "\n",
    "chain = (\n",
    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
    "    | prompt\n",
    "    | model\n",
    "    | StrOutputParser()\n",
    ")\n",
    "\n",
    "chain.invoke(\"where did harrison work?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "id": "OuY62kJ28oNK",
    "outputId": "672ff6df-64d8-442b-9143-f69dbc09f763"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Harrison ha lavorato presso Kensho.\\n\\n(In English: Harrison worked at Kensho.)'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prompt = ChatPromptTemplate.from_messages(\n",
    "    [\n",
    "        (\n",
    "            \"system\",\n",
    "            \"Answer using information solely based on the following context:\\n<Documents>\\n{context}\\n</Documents>\"\n",
    "            \"\\nSpeak only in the following language: {language}\",\n",
    "        ),\n",
    "        (\"user\", \"{question}\"),\n",
    "    ]\n",
    ")\n",
    "\n",
    "chain = (\n",
    "    {\n",
    "        \"context\": itemgetter(\"question\") | retriever,\n",
    "        \"question\": itemgetter(\"question\"),\n",
    "        \"language\": itemgetter(\"language\"),\n",
    "    }\n",
    "    | prompt\n",
    "    | model\n",
    "    | StrOutputParser()\n",
    ")\n",
    "\n",
    "chain.invoke({\"question\": \"where did harrison work\", \"language\": \"italian\"})"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
